/*   
Copyright 2006 - 2010 Intel Corporation

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

using OpenSource.UPnP;

namespace OpenSource.UPnP.AV
{
    /// <summary>
    /// Transparent DeviceSide UPnP Service
    /// </summary>
    public class DvRenderingControl : IUPnPService
    {

        // Place your declarations above this line

        #region AutoGenerated Code Section [Do NOT Modify, unless you know what you're doing]
        //{{{{{ Begin Code Block

        private _DvRenderingControl _S;
        public static string URN = "urn:schemas-upnp-org:service:RenderingControl:1";
        public double VERSION
        {
           get
           {
               return(double.Parse(_S.GetUPnPService().Version));
           }
        }

        public enum Enum_A_ARG_TYPE_PresetName
        {
            FACTORYDEFAULTS,
            INSTALLATIONDEFAULTS,
            VENDOR_DEFINED,
        }
        public Enum_A_ARG_TYPE_PresetName A_ARG_TYPE_PresetName
        {
            set
            {
               string v = "";
               switch(value)
               {
                  case Enum_A_ARG_TYPE_PresetName.FACTORYDEFAULTS:
                     v = "FactoryDefaults";
                     break;
                  case Enum_A_ARG_TYPE_PresetName.INSTALLATIONDEFAULTS:
                     v = "InstallationDefaults";
                     break;
                  case Enum_A_ARG_TYPE_PresetName.VENDOR_DEFINED:
                     v = "Vendor defined";
                     break;
               }
               _S.SetStateVariable("A_ARG_TYPE_PresetName",v);
            }
            get
            {
               Enum_A_ARG_TYPE_PresetName RetVal = 0;
               string v = (string)_S.GetStateVariable("A_ARG_TYPE_PresetName");
               switch(v)
               {
                  case "FactoryDefaults":
                     RetVal = Enum_A_ARG_TYPE_PresetName.FACTORYDEFAULTS;
                     break;
                  case "InstallationDefaults":
                     RetVal = Enum_A_ARG_TYPE_PresetName.INSTALLATIONDEFAULTS;
                     break;
                  case "Vendor defined":
                     RetVal = Enum_A_ARG_TYPE_PresetName.VENDOR_DEFINED;
                     break;
               }
               return(RetVal);
           }
        }
        public enum Enum_A_ARG_TYPE_Channel
        {
            MASTER,
            LF,
            RF,
            CF,
            LFE,
            LS,
            RS,
            LFC,
            RFC,
            SD,
            SL,
            SR,
            T,
            B,
            VENDOR_DEFINED,
        }
        public Enum_A_ARG_TYPE_Channel A_ARG_TYPE_Channel
        {
            set
            {
               string v = "";
               switch(value)
               {
                  case Enum_A_ARG_TYPE_Channel.MASTER:
                     v = "Master";
                     break;
                  case Enum_A_ARG_TYPE_Channel.LF:
                     v = "LF";
                     break;
                  case Enum_A_ARG_TYPE_Channel.RF:
                     v = "RF";
                     break;
                  case Enum_A_ARG_TYPE_Channel.CF:
                     v = "CF";
                     break;
                  case Enum_A_ARG_TYPE_Channel.LFE:
                     v = "LFE";
                     break;
                  case Enum_A_ARG_TYPE_Channel.LS:
                     v = "LS";
                     break;
                  case Enum_A_ARG_TYPE_Channel.RS:
                     v = "RS";
                     break;
                  case Enum_A_ARG_TYPE_Channel.LFC:
                     v = "LFC";
                     break;
                  case Enum_A_ARG_TYPE_Channel.RFC:
                     v = "RFC";
                     break;
                  case Enum_A_ARG_TYPE_Channel.SD:
                     v = "SD";
                     break;
                  case Enum_A_ARG_TYPE_Channel.SL:
                     v = "SL";
                     break;
                  case Enum_A_ARG_TYPE_Channel.SR:
                     v = "SR";
                     break;
                  case Enum_A_ARG_TYPE_Channel.T:
                     v = "T";
                     break;
                  case Enum_A_ARG_TYPE_Channel.B:
                     v = "B";
                     break;
                  case Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED:
                     v = "Vendor defined";
                     break;
               }
               _S.SetStateVariable("A_ARG_TYPE_Channel",v);
            }
            get
            {
               Enum_A_ARG_TYPE_Channel RetVal = 0;
               string v = (string)_S.GetStateVariable("A_ARG_TYPE_Channel");
               switch(v)
               {
                  case "Master":
                     RetVal = Enum_A_ARG_TYPE_Channel.MASTER;
                     break;
                  case "LF":
                     RetVal = Enum_A_ARG_TYPE_Channel.LF;
                     break;
                  case "RF":
                     RetVal = Enum_A_ARG_TYPE_Channel.RF;
                     break;
                  case "CF":
                     RetVal = Enum_A_ARG_TYPE_Channel.CF;
                     break;
                  case "LFE":
                     RetVal = Enum_A_ARG_TYPE_Channel.LFE;
                     break;
                  case "LS":
                     RetVal = Enum_A_ARG_TYPE_Channel.LS;
                     break;
                  case "RS":
                     RetVal = Enum_A_ARG_TYPE_Channel.RS;
                     break;
                  case "LFC":
                     RetVal = Enum_A_ARG_TYPE_Channel.LFC;
                     break;
                  case "RFC":
                     RetVal = Enum_A_ARG_TYPE_Channel.RFC;
                     break;
                  case "SD":
                     RetVal = Enum_A_ARG_TYPE_Channel.SD;
                     break;
                  case "SL":
                     RetVal = Enum_A_ARG_TYPE_Channel.SL;
                     break;
                  case "SR":
                     RetVal = Enum_A_ARG_TYPE_Channel.SR;
                     break;
                  case "T":
                     RetVal = Enum_A_ARG_TYPE_Channel.T;
                     break;
                  case "B":
                     RetVal = Enum_A_ARG_TYPE_Channel.B;
                     break;
                  case "Vendor defined":
                     RetVal = Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED;
                     break;
               }
               return(RetVal);
           }
        }
        static public string Enum_A_ARG_TYPE_PresetName_ToString(Enum_A_ARG_TYPE_PresetName en)
        {
            string RetVal = "";
            switch(en)
            {
                case Enum_A_ARG_TYPE_PresetName.FACTORYDEFAULTS:
                    RetVal = "FactoryDefaults";
                    break;
                case Enum_A_ARG_TYPE_PresetName.INSTALLATIONDEFAULTS:
                    RetVal = "InstallationDefaults";
                    break;
                case Enum_A_ARG_TYPE_PresetName.VENDOR_DEFINED:
                    RetVal = "Vendor defined";
                    break;
            }
            return(RetVal);
        }
        static public string[] Values_A_ARG_TYPE_PresetName
        {
            get
            {
                string[] RetVal = new string[3]{"Vendor defined","InstallationDefaults","FactoryDefaults"};
                return(RetVal);
            }
        }
        static public string Enum_A_ARG_TYPE_Channel_ToString(Enum_A_ARG_TYPE_Channel en)
        {
            string RetVal = "";
            switch(en)
            {
                case Enum_A_ARG_TYPE_Channel.MASTER:
                    RetVal = "Master";
                    break;
                case Enum_A_ARG_TYPE_Channel.LF:
                    RetVal = "LF";
                    break;
                case Enum_A_ARG_TYPE_Channel.RF:
                    RetVal = "RF";
                    break;
                case Enum_A_ARG_TYPE_Channel.CF:
                    RetVal = "CF";
                    break;
                case Enum_A_ARG_TYPE_Channel.LFE:
                    RetVal = "LFE";
                    break;
                case Enum_A_ARG_TYPE_Channel.LS:
                    RetVal = "LS";
                    break;
                case Enum_A_ARG_TYPE_Channel.RS:
                    RetVal = "RS";
                    break;
                case Enum_A_ARG_TYPE_Channel.LFC:
                    RetVal = "LFC";
                    break;
                case Enum_A_ARG_TYPE_Channel.RFC:
                    RetVal = "RFC";
                    break;
                case Enum_A_ARG_TYPE_Channel.SD:
                    RetVal = "SD";
                    break;
                case Enum_A_ARG_TYPE_Channel.SL:
                    RetVal = "SL";
                    break;
                case Enum_A_ARG_TYPE_Channel.SR:
                    RetVal = "SR";
                    break;
                case Enum_A_ARG_TYPE_Channel.T:
                    RetVal = "T";
                    break;
                case Enum_A_ARG_TYPE_Channel.B:
                    RetVal = "B";
                    break;
                case Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED:
                    RetVal = "Vendor defined";
                    break;
            }
            return(RetVal);
        }
        static public string[] Values_A_ARG_TYPE_Channel
        {
            get
            {
                string[] RetVal = new string[15]{"Vendor defined","B","T","SR","SL","SD","RFC","LFC","RS","LS","LFE","CF","RF","LF","Master"};
                return(RetVal);
            }
        }
        public delegate void OnStateVariableModifiedHandler(DvRenderingControl sender);
        public event OnStateVariableModifiedHandler OnStateVariableModified_VerticalKeystone;
        public event OnStateVariableModifiedHandler OnStateVariableModified_LastChange;
        public event OnStateVariableModifiedHandler OnStateVariableModified_A_ARG_TYPE_PresetName;
        public event OnStateVariableModifiedHandler OnStateVariableModified_Loudness;
        public event OnStateVariableModifiedHandler OnStateVariableModified_HorizontalKeystone;
        public event OnStateVariableModifiedHandler OnStateVariableModified_A_ARG_TYPE_InstanceID;
        public event OnStateVariableModifiedHandler OnStateVariableModified_BlueVideoBlackLevel;
        public event OnStateVariableModifiedHandler OnStateVariableModified_RedVideoGain;
        public event OnStateVariableModifiedHandler OnStateVariableModified_GreenVideoBlackLevel;
        public event OnStateVariableModifiedHandler OnStateVariableModified_Volume;
        public event OnStateVariableModifiedHandler OnStateVariableModified_Mute;
        public event OnStateVariableModifiedHandler OnStateVariableModified_Brightness;
        public event OnStateVariableModifiedHandler OnStateVariableModified_PresetNameList;
        public event OnStateVariableModifiedHandler OnStateVariableModified_A_ARG_TYPE_Channel;
        public event OnStateVariableModifiedHandler OnStateVariableModified_ColorTemperature;
        public event OnStateVariableModifiedHandler OnStateVariableModified_VolumeDB;
        public event OnStateVariableModifiedHandler OnStateVariableModified_Contrast;
        public event OnStateVariableModifiedHandler OnStateVariableModified_GreenVideoGain;
        public event OnStateVariableModifiedHandler OnStateVariableModified_RedVideoBlackLevel;
        public event OnStateVariableModifiedHandler OnStateVariableModified_BlueVideoGain;
        public event OnStateVariableModifiedHandler OnStateVariableModified_Sharpness;
        public System.Int16 VerticalKeystone
        {
            get
            {
               return((System.Int16)_S.GetStateVariable("VerticalKeystone"));
            }
            set
            {
               _S.SetStateVariable("VerticalKeystone", value);
            }
        }
        public System.String Evented_LastChange
        {
            get
            {
               return((System.String)_S.GetStateVariable("LastChange"));
            }
            set
            {
               _S.SetStateVariable("LastChange", value);
            }
        }
        public System.Boolean Loudness
        {
            get
            {
               return((System.Boolean)_S.GetStateVariable("Loudness"));
            }
            set
            {
               _S.SetStateVariable("Loudness", value);
            }
        }
        public System.Int16 HorizontalKeystone
        {
            get
            {
               return((System.Int16)_S.GetStateVariable("HorizontalKeystone"));
            }
            set
            {
               _S.SetStateVariable("HorizontalKeystone", value);
            }
        }
        public System.UInt32 A_ARG_TYPE_InstanceID
        {
            get
            {
               return((System.UInt32)_S.GetStateVariable("A_ARG_TYPE_InstanceID"));
            }
            set
            {
               _S.SetStateVariable("A_ARG_TYPE_InstanceID", value);
            }
        }
        public System.UInt16 BlueVideoBlackLevel
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("BlueVideoBlackLevel"));
            }
            set
            {
               _S.SetStateVariable("BlueVideoBlackLevel", value);
            }
        }
        public System.UInt16 RedVideoGain
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("RedVideoGain"));
            }
            set
            {
               _S.SetStateVariable("RedVideoGain", value);
            }
        }
        public System.UInt16 GreenVideoBlackLevel
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("GreenVideoBlackLevel"));
            }
            set
            {
               _S.SetStateVariable("GreenVideoBlackLevel", value);
            }
        }
        public System.UInt16 Volume
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("Volume"));
            }
            set
            {
               _S.SetStateVariable("Volume", value);
            }
        }
        public System.Boolean Mute
        {
            get
            {
               return((System.Boolean)_S.GetStateVariable("Mute"));
            }
            set
            {
               _S.SetStateVariable("Mute", value);
            }
        }
        public System.UInt16 Brightness
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("Brightness"));
            }
            set
            {
               _S.SetStateVariable("Brightness", value);
            }
        }
        public System.String PresetNameList
        {
            get
            {
               return((System.String)_S.GetStateVariable("PresetNameList"));
            }
            set
            {
               _S.SetStateVariable("PresetNameList", value);
            }
        }
        public System.UInt16 ColorTemperature
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("ColorTemperature"));
            }
            set
            {
               _S.SetStateVariable("ColorTemperature", value);
            }
        }
        public System.Int16 VolumeDB
        {
            get
            {
               return((System.Int16)_S.GetStateVariable("VolumeDB"));
            }
            set
            {
               _S.SetStateVariable("VolumeDB", value);
            }
        }
        public System.UInt16 Contrast
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("Contrast"));
            }
            set
            {
               _S.SetStateVariable("Contrast", value);
            }
        }
        public System.UInt16 GreenVideoGain
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("GreenVideoGain"));
            }
            set
            {
               _S.SetStateVariable("GreenVideoGain", value);
            }
        }
        public System.UInt16 RedVideoBlackLevel
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("RedVideoBlackLevel"));
            }
            set
            {
               _S.SetStateVariable("RedVideoBlackLevel", value);
            }
        }
        public System.UInt16 BlueVideoGain
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("BlueVideoGain"));
            }
            set
            {
               _S.SetStateVariable("BlueVideoGain", value);
            }
        }
        public System.UInt16 Sharpness
        {
            get
            {
               return((System.UInt16)_S.GetStateVariable("Sharpness"));
            }
            set
            {
               _S.SetStateVariable("Sharpness", value);
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_VerticalKeystone
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("VerticalKeystone")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("VerticalKeystone")).Accumulator = value;
            }
        }
        public double ModerationDuration_VerticalKeystone
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("VerticalKeystone")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("VerticalKeystone")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_LastChange
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("LastChange")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("LastChange")).Accumulator = value;
            }
        }
        public double ModerationDuration_LastChange
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("LastChange")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("LastChange")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_A_ARG_TYPE_PresetName
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_PresetName")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_PresetName")).Accumulator = value;
            }
        }
        public double ModerationDuration_A_ARG_TYPE_PresetName
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_PresetName")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_PresetName")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_Loudness
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Loudness")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Loudness")).Accumulator = value;
            }
        }
        public double ModerationDuration_Loudness
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Loudness")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Loudness")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_HorizontalKeystone
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("HorizontalKeystone")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("HorizontalKeystone")).Accumulator = value;
            }
        }
        public double ModerationDuration_HorizontalKeystone
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("HorizontalKeystone")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("HorizontalKeystone")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_A_ARG_TYPE_InstanceID
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_InstanceID")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_InstanceID")).Accumulator = value;
            }
        }
        public double ModerationDuration_A_ARG_TYPE_InstanceID
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_InstanceID")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_InstanceID")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_BlueVideoBlackLevel
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("BlueVideoBlackLevel")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("BlueVideoBlackLevel")).Accumulator = value;
            }
        }
        public double ModerationDuration_BlueVideoBlackLevel
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("BlueVideoBlackLevel")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("BlueVideoBlackLevel")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_RedVideoGain
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("RedVideoGain")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("RedVideoGain")).Accumulator = value;
            }
        }
        public double ModerationDuration_RedVideoGain
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("RedVideoGain")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("RedVideoGain")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_GreenVideoBlackLevel
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("GreenVideoBlackLevel")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("GreenVideoBlackLevel")).Accumulator = value;
            }
        }
        public double ModerationDuration_GreenVideoBlackLevel
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("GreenVideoBlackLevel")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("GreenVideoBlackLevel")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_Volume
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Volume")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Volume")).Accumulator = value;
            }
        }
        public double ModerationDuration_Volume
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Volume")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Volume")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_Mute
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Mute")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Mute")).Accumulator = value;
            }
        }
        public double ModerationDuration_Mute
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Mute")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Mute")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_Brightness
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Brightness")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Brightness")).Accumulator = value;
            }
        }
        public double ModerationDuration_Brightness
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Brightness")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Brightness")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_PresetNameList
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("PresetNameList")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("PresetNameList")).Accumulator = value;
            }
        }
        public double ModerationDuration_PresetNameList
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("PresetNameList")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("PresetNameList")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_A_ARG_TYPE_Channel
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_Channel")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_Channel")).Accumulator = value;
            }
        }
        public double ModerationDuration_A_ARG_TYPE_Channel
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_Channel")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_Channel")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_ColorTemperature
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("ColorTemperature")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("ColorTemperature")).Accumulator = value;
            }
        }
        public double ModerationDuration_ColorTemperature
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("ColorTemperature")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("ColorTemperature")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_VolumeDB
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("VolumeDB")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("VolumeDB")).Accumulator = value;
            }
        }
        public double ModerationDuration_VolumeDB
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("VolumeDB")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("VolumeDB")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_Contrast
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Contrast")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Contrast")).Accumulator = value;
            }
        }
        public double ModerationDuration_Contrast
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Contrast")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Contrast")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_GreenVideoGain
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("GreenVideoGain")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("GreenVideoGain")).Accumulator = value;
            }
        }
        public double ModerationDuration_GreenVideoGain
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("GreenVideoGain")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("GreenVideoGain")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_RedVideoBlackLevel
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("RedVideoBlackLevel")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("RedVideoBlackLevel")).Accumulator = value;
            }
        }
        public double ModerationDuration_RedVideoBlackLevel
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("RedVideoBlackLevel")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("RedVideoBlackLevel")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_BlueVideoGain
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("BlueVideoGain")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("BlueVideoGain")).Accumulator = value;
            }
        }
        public double ModerationDuration_BlueVideoGain
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("BlueVideoGain")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("BlueVideoGain")).ModerationPeriod = value;
            }
        }
        public UPnPModeratedStateVariable.IAccumulator Accumulator_Sharpness
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Sharpness")).Accumulator);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Sharpness")).Accumulator = value;
            }
        }
        public double ModerationDuration_Sharpness
        {
            get
            {
                 return(((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Sharpness")).ModerationPeriod);
            }
            set
            {
                 ((UPnPModeratedStateVariable)_S.GetUPnPService().GetStateVariableObject("Sharpness")).ModerationPeriod = value;
            }
        }
        public delegate void Delegate_GetHorizontalKeystone(System.UInt32 InstanceID, out System.Int16 CurrentHorizontalKeystone);
        public delegate void Delegate_GetVolume(System.UInt32 InstanceID, DvRenderingControl.Enum_A_ARG_TYPE_Channel Channel, out System.UInt16 CurrentVolume);
        public delegate void Delegate_SelectPreset(System.UInt32 InstanceID, DvRenderingControl.Enum_A_ARG_TYPE_PresetName PresetName);
        public delegate void Delegate_SetVolume(System.UInt32 InstanceID, DvRenderingControl.Enum_A_ARG_TYPE_Channel Channel, System.UInt16 DesiredVolume);
        public delegate void Delegate_ListPresets(System.UInt32 InstanceID, out System.String CurrentPresetNameList);
        public delegate void Delegate_SetVolumeDB(System.UInt32 InstanceID, DvRenderingControl.Enum_A_ARG_TYPE_Channel Channel, System.Int16 DesiredVolume);
        public delegate void Delegate_SetRedVideoBlackLevel(System.UInt32 InstanceID, System.UInt16 DesiredRedVideoBlackLevel);
        public delegate void Delegate_SetContrast(System.UInt32 InstanceID, System.UInt16 DesiredContrast);
        public delegate void Delegate_SetLoudness(System.UInt32 InstanceID, DvRenderingControl.Enum_A_ARG_TYPE_Channel Channel, System.Boolean DesiredLoudness);
        public delegate void Delegate_SetBrightness(System.UInt32 InstanceID, System.UInt16 DesiredBrightness);
        public delegate void Delegate_GetLoudness(System.UInt32 InstanceID, DvRenderingControl.Enum_A_ARG_TYPE_Channel Channel, out System.Boolean CurrentLoudness);
        public delegate void Delegate_GetColorTemperature(System.UInt32 InstanceID, out System.UInt16 CurrentColorTemperature);
        public delegate void Delegate_GetSharpness(System.UInt32 InstanceID, out System.UInt16 CurrentSharpness);
        public delegate void Delegate_GetContrast(System.UInt32 InstanceID, out System.UInt16 CurrentContrast);
        public delegate void Delegate_GetGreenVideoGain(System.UInt32 InstanceID, out System.UInt16 CurrentGreenVideoGain);
        public delegate void Delegate_SetRedVideoGain(System.UInt32 InstanceID, System.UInt16 DesiredRedVideoGain);
        public delegate void Delegate_SetGreenVideoBlackLevel(System.UInt32 InstanceID, System.UInt16 DesiredGreenVideoBlackLevel);
        public delegate void Delegate_GetVolumeDBRange(System.UInt32 InstanceID, DvRenderingControl.Enum_A_ARG_TYPE_Channel Channel, out System.Int16 MinValue, out System.Int16 MaxValue);
        public delegate void Delegate_GetRedVideoBlackLevel(System.UInt32 InstanceID, out System.UInt16 CurrentRedVideoBlackLevel);
        public delegate void Delegate_GetBlueVideoBlackLevel(System.UInt32 InstanceID, out System.UInt16 CurrentBlueVideoBlackLevel);
        public delegate void Delegate_GetBlueVideoGain(System.UInt32 InstanceID, out System.UInt16 CurrentBlueVideoGain);
        public delegate void Delegate_SetBlueVideoBlackLevel(System.UInt32 InstanceID, System.UInt16 DesiredBlueVideoBlackLevel);
        public delegate void Delegate_GetMute(System.UInt32 InstanceID, DvRenderingControl.Enum_A_ARG_TYPE_Channel Channel, out System.Boolean CurrentMute);
        public delegate void Delegate_SetBlueVideoGain(System.UInt32 InstanceID, System.UInt16 DesiredBlueVideoGain);
        public delegate void Delegate_GetVerticalKeystone(System.UInt32 InstanceID, out System.Int16 CurrentVerticalKeystone);
        public delegate void Delegate_SetVerticalKeystone(System.UInt32 InstanceID, System.Int16 DesiredVerticalKeystone);
        public delegate void Delegate_GetBrightness(System.UInt32 InstanceID, out System.UInt16 CurrentBrightness);
        public delegate void Delegate_GetVolumeDB(System.UInt32 InstanceID, DvRenderingControl.Enum_A_ARG_TYPE_Channel Channel, out System.Int16 CurrentVolume);
        public delegate void Delegate_GetGreenVideoBlackLevel(System.UInt32 InstanceID, out System.UInt16 CurrentGreenVideoBlackLevel);
        public delegate void Delegate_GetRedVideoGain(System.UInt32 InstanceID, out System.UInt16 CurrentRedVideoGain);
        public delegate void Delegate_SetMute(System.UInt32 InstanceID, DvRenderingControl.Enum_A_ARG_TYPE_Channel Channel, System.Boolean DesiredMute);
        public delegate void Delegate_SetGreenVideoGain(System.UInt32 InstanceID, System.UInt16 DesiredGreenVideoGain);
        public delegate void Delegate_SetSharpness(System.UInt32 InstanceID, System.UInt16 DesiredSharpness);
        public delegate void Delegate_SetHorizontalKeystone(System.UInt32 InstanceID, System.Int16 DesiredHorizontalKeystone);
        public delegate void Delegate_SetColorTemperature(System.UInt32 InstanceID, System.UInt16 DesiredColorTemperature);

        public Delegate_GetHorizontalKeystone External_GetHorizontalKeystone = null;
        public Delegate_GetVolume External_GetVolume = null;
        public Delegate_SelectPreset External_SelectPreset = null;
        public Delegate_SetVolume External_SetVolume = null;
        public Delegate_ListPresets External_ListPresets = null;
        public Delegate_SetVolumeDB External_SetVolumeDB = null;
        public Delegate_SetRedVideoBlackLevel External_SetRedVideoBlackLevel = null;
        public Delegate_SetContrast External_SetContrast = null;
        public Delegate_SetLoudness External_SetLoudness = null;
        public Delegate_SetBrightness External_SetBrightness = null;
        public Delegate_GetLoudness External_GetLoudness = null;
        public Delegate_GetColorTemperature External_GetColorTemperature = null;
        public Delegate_GetSharpness External_GetSharpness = null;
        public Delegate_GetContrast External_GetContrast = null;
        public Delegate_GetGreenVideoGain External_GetGreenVideoGain = null;
        public Delegate_SetRedVideoGain External_SetRedVideoGain = null;
        public Delegate_SetGreenVideoBlackLevel External_SetGreenVideoBlackLevel = null;
        public Delegate_GetVolumeDBRange External_GetVolumeDBRange = null;
        public Delegate_GetRedVideoBlackLevel External_GetRedVideoBlackLevel = null;
        public Delegate_GetBlueVideoBlackLevel External_GetBlueVideoBlackLevel = null;
        public Delegate_GetBlueVideoGain External_GetBlueVideoGain = null;
        public Delegate_SetBlueVideoBlackLevel External_SetBlueVideoBlackLevel = null;
        public Delegate_GetMute External_GetMute = null;
        public Delegate_SetBlueVideoGain External_SetBlueVideoGain = null;
        public Delegate_GetVerticalKeystone External_GetVerticalKeystone = null;
        public Delegate_SetVerticalKeystone External_SetVerticalKeystone = null;
        public Delegate_GetBrightness External_GetBrightness = null;
        public Delegate_GetVolumeDB External_GetVolumeDB = null;
        public Delegate_GetGreenVideoBlackLevel External_GetGreenVideoBlackLevel = null;
        public Delegate_GetRedVideoGain External_GetRedVideoGain = null;
        public Delegate_SetMute External_SetMute = null;
        public Delegate_SetGreenVideoGain External_SetGreenVideoGain = null;
        public Delegate_SetSharpness External_SetSharpness = null;
        public Delegate_SetHorizontalKeystone External_SetHorizontalKeystone = null;
        public Delegate_SetColorTemperature External_SetColorTemperature = null;

        public void RemoveStateVariable_VerticalKeystone()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("VerticalKeystone"));
        }
        public void RemoveStateVariable_LastChange()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("LastChange"));
        }
        public void RemoveStateVariable_A_ARG_TYPE_PresetName()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_PresetName"));
        }
        public void RemoveStateVariable_Loudness()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("Loudness"));
        }
        public void RemoveStateVariable_HorizontalKeystone()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("HorizontalKeystone"));
        }
        public void RemoveStateVariable_A_ARG_TYPE_InstanceID()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_InstanceID"));
        }
        public void RemoveStateVariable_BlueVideoBlackLevel()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("BlueVideoBlackLevel"));
        }
        public void RemoveStateVariable_RedVideoGain()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("RedVideoGain"));
        }
        public void RemoveStateVariable_GreenVideoBlackLevel()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("GreenVideoBlackLevel"));
        }
        public void RemoveStateVariable_Volume()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("Volume"));
        }
        public void RemoveStateVariable_Mute()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("Mute"));
        }
        public void RemoveStateVariable_Brightness()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("Brightness"));
        }
        public void RemoveStateVariable_PresetNameList()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("PresetNameList"));
        }
        public void RemoveStateVariable_A_ARG_TYPE_Channel()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_Channel"));
        }
        public void RemoveStateVariable_ColorTemperature()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("ColorTemperature"));
        }
        public void RemoveStateVariable_VolumeDB()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("VolumeDB"));
        }
        public void RemoveStateVariable_Contrast()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("Contrast"));
        }
        public void RemoveStateVariable_GreenVideoGain()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("GreenVideoGain"));
        }
        public void RemoveStateVariable_RedVideoBlackLevel()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("RedVideoBlackLevel"));
        }
        public void RemoveStateVariable_BlueVideoGain()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("BlueVideoGain"));
        }
        public void RemoveStateVariable_Sharpness()
        {
            _S.GetUPnPService().RemoveStateVariable(_S.GetUPnPService().GetStateVariableObject("Sharpness"));
        }
        public void RemoveAction_GetHorizontalKeystone()
        {
             _S.GetUPnPService().RemoveMethod("GetHorizontalKeystone");
        }
        public void RemoveAction_GetVolume()
        {
             _S.GetUPnPService().RemoveMethod("GetVolume");
        }
        public void RemoveAction_SelectPreset()
        {
             _S.GetUPnPService().RemoveMethod("SelectPreset");
        }
        public void RemoveAction_SetVolume()
        {
             _S.GetUPnPService().RemoveMethod("SetVolume");
        }
        public void RemoveAction_ListPresets()
        {
             _S.GetUPnPService().RemoveMethod("ListPresets");
        }
        public void RemoveAction_SetVolumeDB()
        {
             _S.GetUPnPService().RemoveMethod("SetVolumeDB");
        }
        public void RemoveAction_SetRedVideoBlackLevel()
        {
             _S.GetUPnPService().RemoveMethod("SetRedVideoBlackLevel");
        }
        public void RemoveAction_SetContrast()
        {
             _S.GetUPnPService().RemoveMethod("SetContrast");
        }
        public void RemoveAction_SetLoudness()
        {
             _S.GetUPnPService().RemoveMethod("SetLoudness");
        }
        public void RemoveAction_SetBrightness()
        {
             _S.GetUPnPService().RemoveMethod("SetBrightness");
        }
        public void RemoveAction_GetLoudness()
        {
             _S.GetUPnPService().RemoveMethod("GetLoudness");
        }
        public void RemoveAction_GetColorTemperature()
        {
             _S.GetUPnPService().RemoveMethod("GetColorTemperature");
        }
        public void RemoveAction_GetSharpness()
        {
             _S.GetUPnPService().RemoveMethod("GetSharpness");
        }
        public void RemoveAction_GetContrast()
        {
             _S.GetUPnPService().RemoveMethod("GetContrast");
        }
        public void RemoveAction_GetGreenVideoGain()
        {
             _S.GetUPnPService().RemoveMethod("GetGreenVideoGain");
        }
        public void RemoveAction_SetRedVideoGain()
        {
             _S.GetUPnPService().RemoveMethod("SetRedVideoGain");
        }
        public void RemoveAction_SetGreenVideoBlackLevel()
        {
             _S.GetUPnPService().RemoveMethod("SetGreenVideoBlackLevel");
        }
        public void RemoveAction_GetVolumeDBRange()
        {
             _S.GetUPnPService().RemoveMethod("GetVolumeDBRange");
        }
        public void RemoveAction_GetRedVideoBlackLevel()
        {
             _S.GetUPnPService().RemoveMethod("GetRedVideoBlackLevel");
        }
        public void RemoveAction_GetBlueVideoBlackLevel()
        {
             _S.GetUPnPService().RemoveMethod("GetBlueVideoBlackLevel");
        }
        public void RemoveAction_GetBlueVideoGain()
        {
             _S.GetUPnPService().RemoveMethod("GetBlueVideoGain");
        }
        public void RemoveAction_SetBlueVideoBlackLevel()
        {
             _S.GetUPnPService().RemoveMethod("SetBlueVideoBlackLevel");
        }
        public void RemoveAction_GetMute()
        {
             _S.GetUPnPService().RemoveMethod("GetMute");
        }
        public void RemoveAction_SetBlueVideoGain()
        {
             _S.GetUPnPService().RemoveMethod("SetBlueVideoGain");
        }
        public void RemoveAction_GetVerticalKeystone()
        {
             _S.GetUPnPService().RemoveMethod("GetVerticalKeystone");
        }
        public void RemoveAction_SetVerticalKeystone()
        {
             _S.GetUPnPService().RemoveMethod("SetVerticalKeystone");
        }
        public void RemoveAction_GetBrightness()
        {
             _S.GetUPnPService().RemoveMethod("GetBrightness");
        }
        public void RemoveAction_GetVolumeDB()
        {
             _S.GetUPnPService().RemoveMethod("GetVolumeDB");
        }
        public void RemoveAction_GetGreenVideoBlackLevel()
        {
             _S.GetUPnPService().RemoveMethod("GetGreenVideoBlackLevel");
        }
        public void RemoveAction_GetRedVideoGain()
        {
             _S.GetUPnPService().RemoveMethod("GetRedVideoGain");
        }
        public void RemoveAction_SetMute()
        {
             _S.GetUPnPService().RemoveMethod("SetMute");
        }
        public void RemoveAction_SetGreenVideoGain()
        {
             _S.GetUPnPService().RemoveMethod("SetGreenVideoGain");
        }
        public void RemoveAction_SetSharpness()
        {
             _S.GetUPnPService().RemoveMethod("SetSharpness");
        }
        public void RemoveAction_SetHorizontalKeystone()
        {
             _S.GetUPnPService().RemoveMethod("SetHorizontalKeystone");
        }
        public void RemoveAction_SetColorTemperature()
        {
             _S.GetUPnPService().RemoveMethod("SetColorTemperature");
        }
        public System.Net.IPEndPoint GetCaller()
        {
             return(_S.GetUPnPService().GetCaller());
        }
        public System.Net.IPEndPoint GetReceiver()
        {
             return(_S.GetUPnPService().GetReceiver());
        }

        private class _DvRenderingControl
        {
            private DvRenderingControl Outer = null;
            private UPnPService S;
            internal _DvRenderingControl(DvRenderingControl n)
            {
                Outer = n;
                S = BuildUPnPService();
            }
            public UPnPService GetUPnPService()
            {
                return(S);
            }
            public void SetStateVariable(string VarName, object VarValue)
            {
               S.SetStateVariable(VarName,VarValue);
            }
            public object GetStateVariable(string VarName)
            {
               return(S.GetStateVariable(VarName));
            }
            protected UPnPService BuildUPnPService()
            {
                UPnPStateVariable[] RetVal = new UPnPStateVariable[21];
                RetVal[0] = new UPnPModeratedStateVariable("VerticalKeystone", typeof(System.Int16), false);
                RetVal[0].SetRange((System.Int16)(-32768),(System.Int16)(32767),(System.Int16)1);
                RetVal[0].AddAssociation("GetVerticalKeystone", "CurrentVerticalKeystone");
                RetVal[0].AddAssociation("SetVerticalKeystone", "DesiredVerticalKeystone");
                RetVal[1] = new UPnPModeratedStateVariable("LastChange", typeof(System.String), true);
                RetVal[2] = new UPnPModeratedStateVariable("A_ARG_TYPE_PresetName", typeof(System.String), false);
                RetVal[2].AllowedStringValues = new string[3]{"FactoryDefaults", "InstallationDefaults", "Vendor defined"};
                RetVal[2].AddAssociation("SelectPreset", "PresetName");
                RetVal[3] = new UPnPModeratedStateVariable("Loudness", typeof(System.Boolean), false);
                RetVal[3].AddAssociation("SetLoudness", "DesiredLoudness");
                RetVal[3].AddAssociation("GetLoudness", "CurrentLoudness");
                RetVal[4] = new UPnPModeratedStateVariable("HorizontalKeystone", typeof(System.Int16), false);
                RetVal[4].SetRange((System.Int16)(-32768),(System.Int16)(32767),(System.Int16)1);
                RetVal[4].AddAssociation("GetHorizontalKeystone", "CurrentHorizontalKeystone");
                RetVal[4].AddAssociation("SetHorizontalKeystone", "DesiredHorizontalKeystone");
                RetVal[5] = new UPnPModeratedStateVariable("A_ARG_TYPE_InstanceID", typeof(System.UInt32), false);
                RetVal[5].AddAssociation("GetHorizontalKeystone", "InstanceID");
                RetVal[5].AddAssociation("GetVolume", "InstanceID");
                RetVal[5].AddAssociation("SelectPreset", "InstanceID");
                RetVal[5].AddAssociation("SetVolume", "InstanceID");
                RetVal[5].AddAssociation("ListPresets", "InstanceID");
                RetVal[5].AddAssociation("SetVolumeDB", "InstanceID");
                RetVal[5].AddAssociation("SetRedVideoBlackLevel", "InstanceID");
                RetVal[5].AddAssociation("SetContrast", "InstanceID");
                RetVal[5].AddAssociation("SetLoudness", "InstanceID");
                RetVal[5].AddAssociation("SetBrightness", "InstanceID");
                RetVal[5].AddAssociation("GetLoudness", "InstanceID");
                RetVal[5].AddAssociation("GetColorTemperature", "InstanceID");
                RetVal[5].AddAssociation("GetSharpness", "InstanceID");
                RetVal[5].AddAssociation("GetContrast", "InstanceID");
                RetVal[5].AddAssociation("GetGreenVideoGain", "InstanceID");
                RetVal[5].AddAssociation("SetRedVideoGain", "InstanceID");
                RetVal[5].AddAssociation("SetGreenVideoBlackLevel", "InstanceID");
                RetVal[5].AddAssociation("GetVolumeDBRange", "InstanceID");
                RetVal[5].AddAssociation("GetRedVideoBlackLevel", "InstanceID");
                RetVal[5].AddAssociation("GetBlueVideoBlackLevel", "InstanceID");
                RetVal[5].AddAssociation("GetBlueVideoGain", "InstanceID");
                RetVal[5].AddAssociation("SetBlueVideoBlackLevel", "InstanceID");
                RetVal[5].AddAssociation("GetMute", "InstanceID");
                RetVal[5].AddAssociation("SetBlueVideoGain", "InstanceID");
                RetVal[5].AddAssociation("GetVerticalKeystone", "InstanceID");
                RetVal[5].AddAssociation("SetVerticalKeystone", "InstanceID");
                RetVal[5].AddAssociation("GetBrightness", "InstanceID");
                RetVal[5].AddAssociation("GetVolumeDB", "InstanceID");
                RetVal[5].AddAssociation("GetGreenVideoBlackLevel", "InstanceID");
                RetVal[5].AddAssociation("GetRedVideoGain", "InstanceID");
                RetVal[5].AddAssociation("SetMute", "InstanceID");
                RetVal[5].AddAssociation("SetGreenVideoGain", "InstanceID");
                RetVal[5].AddAssociation("SetSharpness", "InstanceID");
                RetVal[5].AddAssociation("SetHorizontalKeystone", "InstanceID");
                RetVal[5].AddAssociation("SetColorTemperature", "InstanceID");
                RetVal[6] = new UPnPModeratedStateVariable("BlueVideoBlackLevel", typeof(System.UInt16), false);
                RetVal[6].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[6].AddAssociation("GetBlueVideoBlackLevel", "CurrentBlueVideoBlackLevel");
                RetVal[6].AddAssociation("SetBlueVideoBlackLevel", "DesiredBlueVideoBlackLevel");
                RetVal[7] = new UPnPModeratedStateVariable("RedVideoGain", typeof(System.UInt16), false);
                RetVal[7].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[7].AddAssociation("SetRedVideoGain", "DesiredRedVideoGain");
                RetVal[7].AddAssociation("GetRedVideoGain", "CurrentRedVideoGain");
                RetVal[8] = new UPnPModeratedStateVariable("GreenVideoBlackLevel", typeof(System.UInt16), false);
                RetVal[8].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[8].AddAssociation("SetGreenVideoBlackLevel", "DesiredGreenVideoBlackLevel");
                RetVal[8].AddAssociation("GetGreenVideoBlackLevel", "CurrentGreenVideoBlackLevel");
                RetVal[9] = new UPnPModeratedStateVariable("Volume", typeof(System.UInt16), false);
                RetVal[9].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[9].AddAssociation("GetVolume", "CurrentVolume");
                RetVal[9].AddAssociation("SetVolume", "DesiredVolume");
                RetVal[10] = new UPnPModeratedStateVariable("Mute", typeof(System.Boolean), false);
                RetVal[10].AddAssociation("GetMute", "CurrentMute");
                RetVal[10].AddAssociation("SetMute", "DesiredMute");
                RetVal[11] = new UPnPModeratedStateVariable("Brightness", typeof(System.UInt16), false);
                RetVal[11].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[11].AddAssociation("SetBrightness", "DesiredBrightness");
                RetVal[11].AddAssociation("GetBrightness", "CurrentBrightness");
                RetVal[12] = new UPnPModeratedStateVariable("PresetNameList", typeof(System.String), false);
                RetVal[12].AddAssociation("ListPresets", "CurrentPresetNameList");
                RetVal[13] = new UPnPModeratedStateVariable("A_ARG_TYPE_Channel", typeof(System.String), false);
                RetVal[13].AllowedStringValues = new string[15]{"Master", "LF", "RF", "CF", "LFE", "LS", "RS", "LFC", "RFC", "SD", "SL", "SR", "T", "B", "Vendor defined"};
                RetVal[13].AddAssociation("GetVolume", "Channel");
                RetVal[13].AddAssociation("SetVolume", "Channel");
                RetVal[13].AddAssociation("SetVolumeDB", "Channel");
                RetVal[13].AddAssociation("SetLoudness", "Channel");
                RetVal[13].AddAssociation("GetLoudness", "Channel");
                RetVal[13].AddAssociation("GetVolumeDBRange", "Channel");
                RetVal[13].AddAssociation("GetMute", "Channel");
                RetVal[13].AddAssociation("GetVolumeDB", "Channel");
                RetVal[13].AddAssociation("SetMute", "Channel");
                RetVal[14] = new UPnPModeratedStateVariable("ColorTemperature", typeof(System.UInt16), false);
                RetVal[14].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[14].AddAssociation("GetColorTemperature", "CurrentColorTemperature");
                RetVal[14].AddAssociation("SetColorTemperature", "DesiredColorTemperature");
                RetVal[15] = new UPnPModeratedStateVariable("VolumeDB", typeof(System.Int16), false);
                RetVal[15].SetRange((System.Int16)(-32768),(System.Int16)(32767),null);
                RetVal[15].AddAssociation("SetVolumeDB", "DesiredVolume");
                RetVal[15].AddAssociation("GetVolumeDBRange", "MinValue");
                RetVal[15].AddAssociation("GetVolumeDBRange", "MaxValue");
                RetVal[15].AddAssociation("GetVolumeDB", "CurrentVolume");
                RetVal[16] = new UPnPModeratedStateVariable("Contrast", typeof(System.UInt16), false);
                RetVal[16].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[16].AddAssociation("SetContrast", "DesiredContrast");
                RetVal[16].AddAssociation("GetContrast", "CurrentContrast");
                RetVal[17] = new UPnPModeratedStateVariable("GreenVideoGain", typeof(System.UInt16), false);
                RetVal[17].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[17].AddAssociation("GetGreenVideoGain", "CurrentGreenVideoGain");
                RetVal[17].AddAssociation("SetGreenVideoGain", "DesiredGreenVideoGain");
                RetVal[18] = new UPnPModeratedStateVariable("RedVideoBlackLevel", typeof(System.UInt16), false);
                RetVal[18].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[18].AddAssociation("SetRedVideoBlackLevel", "DesiredRedVideoBlackLevel");
                RetVal[18].AddAssociation("GetRedVideoBlackLevel", "CurrentRedVideoBlackLevel");
                RetVal[19] = new UPnPModeratedStateVariable("BlueVideoGain", typeof(System.UInt16), false);
                RetVal[19].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[19].AddAssociation("GetBlueVideoGain", "CurrentBlueVideoGain");
                RetVal[19].AddAssociation("SetBlueVideoGain", "DesiredBlueVideoGain");
                RetVal[20] = new UPnPModeratedStateVariable("Sharpness", typeof(System.UInt16), false);
                RetVal[20].SetRange((System.UInt16)(0),(System.UInt16)(65535),(System.UInt16)1);
                RetVal[20].AddAssociation("GetSharpness", "CurrentSharpness");
                RetVal[20].AddAssociation("SetSharpness", "DesiredSharpness");

                UPnPService S = new UPnPService(1, "urn:schemas-upnp-org:service:RenderingControl", "urn:schemas-upnp-org:service:RenderingControl:1", true, this);
                for(int i=0;i<RetVal.Length;++i)
                {
                   S.AddStateVariable(RetVal[i]);
                }
                S.AddMethod("GetHorizontalKeystone");
                S.AddMethod("GetVolume");
                S.AddMethod("SelectPreset");
                S.AddMethod("SetVolume");
                S.AddMethod("ListPresets");
                S.AddMethod("SetVolumeDB");
                S.AddMethod("SetRedVideoBlackLevel");
                S.AddMethod("SetContrast");
                S.AddMethod("SetLoudness");
                S.AddMethod("SetBrightness");
                S.AddMethod("GetLoudness");
                S.AddMethod("GetColorTemperature");
                S.AddMethod("GetSharpness");
                S.AddMethod("GetContrast");
                S.AddMethod("GetGreenVideoGain");
                S.AddMethod("SetRedVideoGain");
                S.AddMethod("SetGreenVideoBlackLevel");
                S.AddMethod("GetVolumeDBRange");
                S.AddMethod("GetRedVideoBlackLevel");
                S.AddMethod("GetBlueVideoBlackLevel");
                S.AddMethod("GetBlueVideoGain");
                S.AddMethod("SetBlueVideoBlackLevel");
                S.AddMethod("GetMute");
                S.AddMethod("SetBlueVideoGain");
                S.AddMethod("GetVerticalKeystone");
                S.AddMethod("SetVerticalKeystone");
                S.AddMethod("GetBrightness");
                S.AddMethod("GetVolumeDB");
                S.AddMethod("GetGreenVideoBlackLevel");
                S.AddMethod("GetRedVideoGain");
                S.AddMethod("SetMute");
                S.AddMethod("SetGreenVideoGain");
                S.AddMethod("SetSharpness");
                S.AddMethod("SetHorizontalKeystone");
                S.AddMethod("SetColorTemperature");
                return(S);
            }

            public void GetHorizontalKeystone(System.UInt32 InstanceID, out System.Int16 CurrentHorizontalKeystone)
            {
                if(Outer.External_GetHorizontalKeystone != null)
                {
                    Outer.External_GetHorizontalKeystone(InstanceID, out CurrentHorizontalKeystone);
                }
                else
                {
                    Sink_GetHorizontalKeystone(InstanceID, out CurrentHorizontalKeystone);
                }
            }
            public void GetVolume(System.UInt32 InstanceID, System.String Channel, out System.UInt16 CurrentVolume)
            {
                Enum_A_ARG_TYPE_Channel e_Channel;
                switch(Channel)
                {
                    case "Master":
                        e_Channel = Enum_A_ARG_TYPE_Channel.MASTER;
                        break;
                    case "LF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LF;
                        break;
                    case "RF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RF;
                        break;
                    case "CF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.CF;
                        break;
                    case "LFE":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFE;
                        break;
                    case "LS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LS;
                        break;
                    case "RS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RS;
                        break;
                    case "LFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFC;
                        break;
                    case "RFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RFC;
                        break;
                    case "SD":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SD;
                        break;
                    case "SL":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SL;
                        break;
                    case "SR":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SR;
                        break;
                    case "T":
                        e_Channel = Enum_A_ARG_TYPE_Channel.T;
                        break;
                    case "B":
                        e_Channel = Enum_A_ARG_TYPE_Channel.B;
                        break;
                    case "Vendor defined":
                        e_Channel = Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED;
                        break;
                    default:
                        e_Channel = 0;
                        break;
                }
                if(Outer.External_GetVolume != null)
                {
                    Outer.External_GetVolume(InstanceID, e_Channel, out CurrentVolume);
                }
                else
                {
                    Sink_GetVolume(InstanceID, e_Channel, out CurrentVolume);
                }
            }
            public void SelectPreset(System.UInt32 InstanceID, System.String PresetName)
            {
                Enum_A_ARG_TYPE_PresetName e_PresetName;
                switch(PresetName)
                {
                    case "FactoryDefaults":
                        e_PresetName = Enum_A_ARG_TYPE_PresetName.FACTORYDEFAULTS;
                        break;
                    case "InstallationDefaults":
                        e_PresetName = Enum_A_ARG_TYPE_PresetName.INSTALLATIONDEFAULTS;
                        break;
                    case "Vendor defined":
                        e_PresetName = Enum_A_ARG_TYPE_PresetName.VENDOR_DEFINED;
                        break;
                    default:
                        e_PresetName = 0;
                        break;
                }
                if(Outer.External_SelectPreset != null)
                {
                    Outer.External_SelectPreset(InstanceID, e_PresetName);
                }
                else
                {
                    Sink_SelectPreset(InstanceID, e_PresetName);
                }
            }
            public void SetVolume(System.UInt32 InstanceID, System.String Channel, System.UInt16 DesiredVolume)
            {
                Enum_A_ARG_TYPE_Channel e_Channel;
                switch(Channel)
                {
                    case "Master":
                        e_Channel = Enum_A_ARG_TYPE_Channel.MASTER;
                        break;
                    case "LF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LF;
                        break;
                    case "RF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RF;
                        break;
                    case "CF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.CF;
                        break;
                    case "LFE":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFE;
                        break;
                    case "LS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LS;
                        break;
                    case "RS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RS;
                        break;
                    case "LFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFC;
                        break;
                    case "RFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RFC;
                        break;
                    case "SD":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SD;
                        break;
                    case "SL":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SL;
                        break;
                    case "SR":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SR;
                        break;
                    case "T":
                        e_Channel = Enum_A_ARG_TYPE_Channel.T;
                        break;
                    case "B":
                        e_Channel = Enum_A_ARG_TYPE_Channel.B;
                        break;
                    case "Vendor defined":
                        e_Channel = Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED;
                        break;
                    default:
                        e_Channel = 0;
                        break;
                }
                if(Outer.External_SetVolume != null)
                {
                    Outer.External_SetVolume(InstanceID, e_Channel, DesiredVolume);
                }
                else
                {
                    Sink_SetVolume(InstanceID, e_Channel, DesiredVolume);
                }
            }
            public void ListPresets(System.UInt32 InstanceID, out System.String CurrentPresetNameList)
            {
                if(Outer.External_ListPresets != null)
                {
                    Outer.External_ListPresets(InstanceID, out CurrentPresetNameList);
                }
                else
                {
                    Sink_ListPresets(InstanceID, out CurrentPresetNameList);
                }
            }
            public void SetVolumeDB(System.UInt32 InstanceID, System.String Channel, System.Int16 DesiredVolume)
            {
                Enum_A_ARG_TYPE_Channel e_Channel;
                switch(Channel)
                {
                    case "Master":
                        e_Channel = Enum_A_ARG_TYPE_Channel.MASTER;
                        break;
                    case "LF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LF;
                        break;
                    case "RF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RF;
                        break;
                    case "CF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.CF;
                        break;
                    case "LFE":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFE;
                        break;
                    case "LS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LS;
                        break;
                    case "RS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RS;
                        break;
                    case "LFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFC;
                        break;
                    case "RFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RFC;
                        break;
                    case "SD":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SD;
                        break;
                    case "SL":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SL;
                        break;
                    case "SR":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SR;
                        break;
                    case "T":
                        e_Channel = Enum_A_ARG_TYPE_Channel.T;
                        break;
                    case "B":
                        e_Channel = Enum_A_ARG_TYPE_Channel.B;
                        break;
                    case "Vendor defined":
                        e_Channel = Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED;
                        break;
                    default:
                        e_Channel = 0;
                        break;
                }
                if(Outer.External_SetVolumeDB != null)
                {
                    Outer.External_SetVolumeDB(InstanceID, e_Channel, DesiredVolume);
                }
                else
                {
                    Sink_SetVolumeDB(InstanceID, e_Channel, DesiredVolume);
                }
            }
            public void SetRedVideoBlackLevel(System.UInt32 InstanceID, System.UInt16 DesiredRedVideoBlackLevel)
            {
                if(Outer.External_SetRedVideoBlackLevel != null)
                {
                    Outer.External_SetRedVideoBlackLevel(InstanceID, DesiredRedVideoBlackLevel);
                }
                else
                {
                    Sink_SetRedVideoBlackLevel(InstanceID, DesiredRedVideoBlackLevel);
                }
            }
            public void SetContrast(System.UInt32 InstanceID, System.UInt16 DesiredContrast)
            {
                if(Outer.External_SetContrast != null)
                {
                    Outer.External_SetContrast(InstanceID, DesiredContrast);
                }
                else
                {
                    Sink_SetContrast(InstanceID, DesiredContrast);
                }
            }
            public void SetLoudness(System.UInt32 InstanceID, System.String Channel, System.Boolean DesiredLoudness)
            {
                Enum_A_ARG_TYPE_Channel e_Channel;
                switch(Channel)
                {
                    case "Master":
                        e_Channel = Enum_A_ARG_TYPE_Channel.MASTER;
                        break;
                    case "LF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LF;
                        break;
                    case "RF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RF;
                        break;
                    case "CF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.CF;
                        break;
                    case "LFE":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFE;
                        break;
                    case "LS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LS;
                        break;
                    case "RS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RS;
                        break;
                    case "LFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFC;
                        break;
                    case "RFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RFC;
                        break;
                    case "SD":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SD;
                        break;
                    case "SL":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SL;
                        break;
                    case "SR":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SR;
                        break;
                    case "T":
                        e_Channel = Enum_A_ARG_TYPE_Channel.T;
                        break;
                    case "B":
                        e_Channel = Enum_A_ARG_TYPE_Channel.B;
                        break;
                    case "Vendor defined":
                        e_Channel = Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED;
                        break;
                    default:
                        e_Channel = 0;
                        break;
                }
                if(Outer.External_SetLoudness != null)
                {
                    Outer.External_SetLoudness(InstanceID, e_Channel, DesiredLoudness);
                }
                else
                {
                    Sink_SetLoudness(InstanceID, e_Channel, DesiredLoudness);
                }
            }
            public void SetBrightness(System.UInt32 InstanceID, System.UInt16 DesiredBrightness)
            {
                if(Outer.External_SetBrightness != null)
                {
                    Outer.External_SetBrightness(InstanceID, DesiredBrightness);
                }
                else
                {
                    Sink_SetBrightness(InstanceID, DesiredBrightness);
                }
            }
            public void GetLoudness(System.UInt32 InstanceID, System.String Channel, out System.Boolean CurrentLoudness)
            {
                Enum_A_ARG_TYPE_Channel e_Channel;
                switch(Channel)
                {
                    case "Master":
                        e_Channel = Enum_A_ARG_TYPE_Channel.MASTER;
                        break;
                    case "LF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LF;
                        break;
                    case "RF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RF;
                        break;
                    case "CF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.CF;
                        break;
                    case "LFE":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFE;
                        break;
                    case "LS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LS;
                        break;
                    case "RS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RS;
                        break;
                    case "LFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFC;
                        break;
                    case "RFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RFC;
                        break;
                    case "SD":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SD;
                        break;
                    case "SL":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SL;
                        break;
                    case "SR":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SR;
                        break;
                    case "T":
                        e_Channel = Enum_A_ARG_TYPE_Channel.T;
                        break;
                    case "B":
                        e_Channel = Enum_A_ARG_TYPE_Channel.B;
                        break;
                    case "Vendor defined":
                        e_Channel = Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED;
                        break;
                    default:
                        e_Channel = 0;
                        break;
                }
                if(Outer.External_GetLoudness != null)
                {
                    Outer.External_GetLoudness(InstanceID, e_Channel, out CurrentLoudness);
                }
                else
                {
                    Sink_GetLoudness(InstanceID, e_Channel, out CurrentLoudness);
                }
            }
            public void GetColorTemperature(System.UInt32 InstanceID, out System.UInt16 CurrentColorTemperature)
            {
                if(Outer.External_GetColorTemperature != null)
                {
                    Outer.External_GetColorTemperature(InstanceID, out CurrentColorTemperature);
                }
                else
                {
                    Sink_GetColorTemperature(InstanceID, out CurrentColorTemperature);
                }
            }
            public void GetSharpness(System.UInt32 InstanceID, out System.UInt16 CurrentSharpness)
            {
                if(Outer.External_GetSharpness != null)
                {
                    Outer.External_GetSharpness(InstanceID, out CurrentSharpness);
                }
                else
                {
                    Sink_GetSharpness(InstanceID, out CurrentSharpness);
                }
            }
            public void GetContrast(System.UInt32 InstanceID, out System.UInt16 CurrentContrast)
            {
                if(Outer.External_GetContrast != null)
                {
                    Outer.External_GetContrast(InstanceID, out CurrentContrast);
                }
                else
                {
                    Sink_GetContrast(InstanceID, out CurrentContrast);
                }
            }
            public void GetGreenVideoGain(System.UInt32 InstanceID, out System.UInt16 CurrentGreenVideoGain)
            {
                if(Outer.External_GetGreenVideoGain != null)
                {
                    Outer.External_GetGreenVideoGain(InstanceID, out CurrentGreenVideoGain);
                }
                else
                {
                    Sink_GetGreenVideoGain(InstanceID, out CurrentGreenVideoGain);
                }
            }
            public void SetRedVideoGain(System.UInt32 InstanceID, System.UInt16 DesiredRedVideoGain)
            {
                if(Outer.External_SetRedVideoGain != null)
                {
                    Outer.External_SetRedVideoGain(InstanceID, DesiredRedVideoGain);
                }
                else
                {
                    Sink_SetRedVideoGain(InstanceID, DesiredRedVideoGain);
                }
            }
            public void SetGreenVideoBlackLevel(System.UInt32 InstanceID, System.UInt16 DesiredGreenVideoBlackLevel)
            {
                if(Outer.External_SetGreenVideoBlackLevel != null)
                {
                    Outer.External_SetGreenVideoBlackLevel(InstanceID, DesiredGreenVideoBlackLevel);
                }
                else
                {
                    Sink_SetGreenVideoBlackLevel(InstanceID, DesiredGreenVideoBlackLevel);
                }
            }
            public void GetVolumeDBRange(System.UInt32 InstanceID, System.String Channel, out System.Int16 MinValue, out System.Int16 MaxValue)
            {
                Enum_A_ARG_TYPE_Channel e_Channel;
                switch(Channel)
                {
                    case "Master":
                        e_Channel = Enum_A_ARG_TYPE_Channel.MASTER;
                        break;
                    case "LF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LF;
                        break;
                    case "RF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RF;
                        break;
                    case "CF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.CF;
                        break;
                    case "LFE":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFE;
                        break;
                    case "LS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LS;
                        break;
                    case "RS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RS;
                        break;
                    case "LFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFC;
                        break;
                    case "RFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RFC;
                        break;
                    case "SD":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SD;
                        break;
                    case "SL":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SL;
                        break;
                    case "SR":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SR;
                        break;
                    case "T":
                        e_Channel = Enum_A_ARG_TYPE_Channel.T;
                        break;
                    case "B":
                        e_Channel = Enum_A_ARG_TYPE_Channel.B;
                        break;
                    case "Vendor defined":
                        e_Channel = Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED;
                        break;
                    default:
                        e_Channel = 0;
                        break;
                }
                if(Outer.External_GetVolumeDBRange != null)
                {
                    Outer.External_GetVolumeDBRange(InstanceID, e_Channel, out MinValue, out MaxValue);
                }
                else
                {
                    Sink_GetVolumeDBRange(InstanceID, e_Channel, out MinValue, out MaxValue);
                }
            }
            public void GetRedVideoBlackLevel(System.UInt32 InstanceID, out System.UInt16 CurrentRedVideoBlackLevel)
            {
                if(Outer.External_GetRedVideoBlackLevel != null)
                {
                    Outer.External_GetRedVideoBlackLevel(InstanceID, out CurrentRedVideoBlackLevel);
                }
                else
                {
                    Sink_GetRedVideoBlackLevel(InstanceID, out CurrentRedVideoBlackLevel);
                }
            }
            public void GetBlueVideoBlackLevel(System.UInt32 InstanceID, out System.UInt16 CurrentBlueVideoBlackLevel)
            {
                if(Outer.External_GetBlueVideoBlackLevel != null)
                {
                    Outer.External_GetBlueVideoBlackLevel(InstanceID, out CurrentBlueVideoBlackLevel);
                }
                else
                {
                    Sink_GetBlueVideoBlackLevel(InstanceID, out CurrentBlueVideoBlackLevel);
                }
            }
            public void GetBlueVideoGain(System.UInt32 InstanceID, out System.UInt16 CurrentBlueVideoGain)
            {
                if(Outer.External_GetBlueVideoGain != null)
                {
                    Outer.External_GetBlueVideoGain(InstanceID, out CurrentBlueVideoGain);
                }
                else
                {
                    Sink_GetBlueVideoGain(InstanceID, out CurrentBlueVideoGain);
                }
            }
            public void SetBlueVideoBlackLevel(System.UInt32 InstanceID, System.UInt16 DesiredBlueVideoBlackLevel)
            {
                if(Outer.External_SetBlueVideoBlackLevel != null)
                {
                    Outer.External_SetBlueVideoBlackLevel(InstanceID, DesiredBlueVideoBlackLevel);
                }
                else
                {
                    Sink_SetBlueVideoBlackLevel(InstanceID, DesiredBlueVideoBlackLevel);
                }
            }
            public void GetMute(System.UInt32 InstanceID, System.String Channel, out System.Boolean CurrentMute)
            {
                Enum_A_ARG_TYPE_Channel e_Channel;
                switch(Channel)
                {
                    case "Master":
                        e_Channel = Enum_A_ARG_TYPE_Channel.MASTER;
                        break;
                    case "LF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LF;
                        break;
                    case "RF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RF;
                        break;
                    case "CF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.CF;
                        break;
                    case "LFE":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFE;
                        break;
                    case "LS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LS;
                        break;
                    case "RS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RS;
                        break;
                    case "LFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFC;
                        break;
                    case "RFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RFC;
                        break;
                    case "SD":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SD;
                        break;
                    case "SL":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SL;
                        break;
                    case "SR":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SR;
                        break;
                    case "T":
                        e_Channel = Enum_A_ARG_TYPE_Channel.T;
                        break;
                    case "B":
                        e_Channel = Enum_A_ARG_TYPE_Channel.B;
                        break;
                    case "Vendor defined":
                        e_Channel = Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED;
                        break;
                    default:
                        e_Channel = 0;
                        break;
                }
                if(Outer.External_GetMute != null)
                {
                    Outer.External_GetMute(InstanceID, e_Channel, out CurrentMute);
                }
                else
                {
                    Sink_GetMute(InstanceID, e_Channel, out CurrentMute);
                }
            }
            public void SetBlueVideoGain(System.UInt32 InstanceID, System.UInt16 DesiredBlueVideoGain)
            {
                if(Outer.External_SetBlueVideoGain != null)
                {
                    Outer.External_SetBlueVideoGain(InstanceID, DesiredBlueVideoGain);
                }
                else
                {
                    Sink_SetBlueVideoGain(InstanceID, DesiredBlueVideoGain);
                }
            }
            public void GetVerticalKeystone(System.UInt32 InstanceID, out System.Int16 CurrentVerticalKeystone)
            {
                if(Outer.External_GetVerticalKeystone != null)
                {
                    Outer.External_GetVerticalKeystone(InstanceID, out CurrentVerticalKeystone);
                }
                else
                {
                    Sink_GetVerticalKeystone(InstanceID, out CurrentVerticalKeystone);
                }
            }
            public void SetVerticalKeystone(System.UInt32 InstanceID, System.Int16 DesiredVerticalKeystone)
            {
                if(Outer.External_SetVerticalKeystone != null)
                {
                    Outer.External_SetVerticalKeystone(InstanceID, DesiredVerticalKeystone);
                }
                else
                {
                    Sink_SetVerticalKeystone(InstanceID, DesiredVerticalKeystone);
                }
            }
            public void GetBrightness(System.UInt32 InstanceID, out System.UInt16 CurrentBrightness)
            {
                if(Outer.External_GetBrightness != null)
                {
                    Outer.External_GetBrightness(InstanceID, out CurrentBrightness);
                }
                else
                {
                    Sink_GetBrightness(InstanceID, out CurrentBrightness);
                }
            }
            public void GetVolumeDB(System.UInt32 InstanceID, System.String Channel, out System.Int16 CurrentVolume)
            {
                Enum_A_ARG_TYPE_Channel e_Channel;
                switch(Channel)
                {
                    case "Master":
                        e_Channel = Enum_A_ARG_TYPE_Channel.MASTER;
                        break;
                    case "LF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LF;
                        break;
                    case "RF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RF;
                        break;
                    case "CF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.CF;
                        break;
                    case "LFE":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFE;
                        break;
                    case "LS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LS;
                        break;
                    case "RS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RS;
                        break;
                    case "LFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFC;
                        break;
                    case "RFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RFC;
                        break;
                    case "SD":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SD;
                        break;
                    case "SL":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SL;
                        break;
                    case "SR":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SR;
                        break;
                    case "T":
                        e_Channel = Enum_A_ARG_TYPE_Channel.T;
                        break;
                    case "B":
                        e_Channel = Enum_A_ARG_TYPE_Channel.B;
                        break;
                    case "Vendor defined":
                        e_Channel = Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED;
                        break;
                    default:
                        e_Channel = 0;
                        break;
                }
                if(Outer.External_GetVolumeDB != null)
                {
                    Outer.External_GetVolumeDB(InstanceID, e_Channel, out CurrentVolume);
                }
                else
                {
                    Sink_GetVolumeDB(InstanceID, e_Channel, out CurrentVolume);
                }
            }
            public void GetGreenVideoBlackLevel(System.UInt32 InstanceID, out System.UInt16 CurrentGreenVideoBlackLevel)
            {
                if(Outer.External_GetGreenVideoBlackLevel != null)
                {
                    Outer.External_GetGreenVideoBlackLevel(InstanceID, out CurrentGreenVideoBlackLevel);
                }
                else
                {
                    Sink_GetGreenVideoBlackLevel(InstanceID, out CurrentGreenVideoBlackLevel);
                }
            }
            public void GetRedVideoGain(System.UInt32 InstanceID, out System.UInt16 CurrentRedVideoGain)
            {
                if(Outer.External_GetRedVideoGain != null)
                {
                    Outer.External_GetRedVideoGain(InstanceID, out CurrentRedVideoGain);
                }
                else
                {
                    Sink_GetRedVideoGain(InstanceID, out CurrentRedVideoGain);
                }
            }
            public void SetMute(System.UInt32 InstanceID, System.String Channel, System.Boolean DesiredMute)
            {
                Enum_A_ARG_TYPE_Channel e_Channel;
                switch(Channel)
                {
                    case "Master":
                        e_Channel = Enum_A_ARG_TYPE_Channel.MASTER;
                        break;
                    case "LF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LF;
                        break;
                    case "RF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RF;
                        break;
                    case "CF":
                        e_Channel = Enum_A_ARG_TYPE_Channel.CF;
                        break;
                    case "LFE":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFE;
                        break;
                    case "LS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LS;
                        break;
                    case "RS":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RS;
                        break;
                    case "LFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.LFC;
                        break;
                    case "RFC":
                        e_Channel = Enum_A_ARG_TYPE_Channel.RFC;
                        break;
                    case "SD":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SD;
                        break;
                    case "SL":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SL;
                        break;
                    case "SR":
                        e_Channel = Enum_A_ARG_TYPE_Channel.SR;
                        break;
                    case "T":
                        e_Channel = Enum_A_ARG_TYPE_Channel.T;
                        break;
                    case "B":
                        e_Channel = Enum_A_ARG_TYPE_Channel.B;
                        break;
                    case "Vendor defined":
                        e_Channel = Enum_A_ARG_TYPE_Channel.VENDOR_DEFINED;
                        break;
                    default:
                        e_Channel = 0;
                        break;
                }
                if(Outer.External_SetMute != null)
                {
                    Outer.External_SetMute(InstanceID, e_Channel, DesiredMute);
                }
                else
                {
                    Sink_SetMute(InstanceID, e_Channel, DesiredMute);
                }
            }
            public void SetGreenVideoGain(System.UInt32 InstanceID, System.UInt16 DesiredGreenVideoGain)
            {
                if(Outer.External_SetGreenVideoGain != null)
                {
                    Outer.External_SetGreenVideoGain(InstanceID, DesiredGreenVideoGain);
                }
                else
                {
                    Sink_SetGreenVideoGain(InstanceID, DesiredGreenVideoGain);
                }
            }
            public void SetSharpness(System.UInt32 InstanceID, System.UInt16 DesiredSharpness)
            {
                if(Outer.External_SetSharpness != null)
                {
                    Outer.External_SetSharpness(InstanceID, DesiredSharpness);
                }
                else
                {
                    Sink_SetSharpness(InstanceID, DesiredSharpness);
                }
            }
            public void SetHorizontalKeystone(System.UInt32 InstanceID, System.Int16 DesiredHorizontalKeystone)
            {
                if(Outer.External_SetHorizontalKeystone != null)
                {
                    Outer.External_SetHorizontalKeystone(InstanceID, DesiredHorizontalKeystone);
                }
                else
                {
                    Sink_SetHorizontalKeystone(InstanceID, DesiredHorizontalKeystone);
                }
            }
            public void SetColorTemperature(System.UInt32 InstanceID, System.UInt16 DesiredColorTemperature)
            {
                if(Outer.External_SetColorTemperature != null)
                {
                    Outer.External_SetColorTemperature(InstanceID, DesiredColorTemperature);
                }
                else
                {
                    Sink_SetColorTemperature(InstanceID, DesiredColorTemperature);
                }
            }

            public Delegate_GetHorizontalKeystone Sink_GetHorizontalKeystone;
            public Delegate_GetVolume Sink_GetVolume;
            public Delegate_SelectPreset Sink_SelectPreset;
            public Delegate_SetVolume Sink_SetVolume;
            public Delegate_ListPresets Sink_ListPresets;
            public Delegate_SetVolumeDB Sink_SetVolumeDB;
            public Delegate_SetRedVideoBlackLevel Sink_SetRedVideoBlackLevel;
            public Delegate_SetContrast Sink_SetContrast;
            public Delegate_SetLoudness Sink_SetLoudness;
            public Delegate_SetBrightness Sink_SetBrightness;
            public Delegate_GetLoudness Sink_GetLoudness;
            public Delegate_GetColorTemperature Sink_GetColorTemperature;
            public Delegate_GetSharpness Sink_GetSharpness;
            public Delegate_GetContrast Sink_GetContrast;
            public Delegate_GetGreenVideoGain Sink_GetGreenVideoGain;
            public Delegate_SetRedVideoGain Sink_SetRedVideoGain;
            public Delegate_SetGreenVideoBlackLevel Sink_SetGreenVideoBlackLevel;
            public Delegate_GetVolumeDBRange Sink_GetVolumeDBRange;
            public Delegate_GetRedVideoBlackLevel Sink_GetRedVideoBlackLevel;
            public Delegate_GetBlueVideoBlackLevel Sink_GetBlueVideoBlackLevel;
            public Delegate_GetBlueVideoGain Sink_GetBlueVideoGain;
            public Delegate_SetBlueVideoBlackLevel Sink_SetBlueVideoBlackLevel;
            public Delegate_GetMute Sink_GetMute;
            public Delegate_SetBlueVideoGain Sink_SetBlueVideoGain;
            public Delegate_GetVerticalKeystone Sink_GetVerticalKeystone;
            public Delegate_SetVerticalKeystone Sink_SetVerticalKeystone;
            public Delegate_GetBrightness Sink_GetBrightness;
            public Delegate_GetVolumeDB Sink_GetVolumeDB;
            public Delegate_GetGreenVideoBlackLevel Sink_GetGreenVideoBlackLevel;
            public Delegate_GetRedVideoGain Sink_GetRedVideoGain;
            public Delegate_SetMute Sink_SetMute;
            public Delegate_SetGreenVideoGain Sink_SetGreenVideoGain;
            public Delegate_SetSharpness Sink_SetSharpness;
            public Delegate_SetHorizontalKeystone Sink_SetHorizontalKeystone;
            public Delegate_SetColorTemperature Sink_SetColorTemperature;
        }
        public DvRenderingControl()
        {
            _S = new _DvRenderingControl(this);
            _S.GetUPnPService().GetStateVariableObject("VerticalKeystone").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_VerticalKeystone);
            _S.GetUPnPService().GetStateVariableObject("LastChange").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_LastChange);
            _S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_PresetName").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_A_ARG_TYPE_PresetName);
            _S.GetUPnPService().GetStateVariableObject("Loudness").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_Loudness);
            _S.GetUPnPService().GetStateVariableObject("HorizontalKeystone").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_HorizontalKeystone);
            _S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_InstanceID").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_A_ARG_TYPE_InstanceID);
            _S.GetUPnPService().GetStateVariableObject("BlueVideoBlackLevel").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_BlueVideoBlackLevel);
            _S.GetUPnPService().GetStateVariableObject("RedVideoGain").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_RedVideoGain);
            _S.GetUPnPService().GetStateVariableObject("GreenVideoBlackLevel").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_GreenVideoBlackLevel);
            _S.GetUPnPService().GetStateVariableObject("Volume").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_Volume);
            _S.GetUPnPService().GetStateVariableObject("Mute").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_Mute);
            _S.GetUPnPService().GetStateVariableObject("Brightness").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_Brightness);
            _S.GetUPnPService().GetStateVariableObject("PresetNameList").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_PresetNameList);
            _S.GetUPnPService().GetStateVariableObject("A_ARG_TYPE_Channel").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_A_ARG_TYPE_Channel);
            _S.GetUPnPService().GetStateVariableObject("ColorTemperature").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_ColorTemperature);
            _S.GetUPnPService().GetStateVariableObject("VolumeDB").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_VolumeDB);
            _S.GetUPnPService().GetStateVariableObject("Contrast").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_Contrast);
            _S.GetUPnPService().GetStateVariableObject("GreenVideoGain").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_GreenVideoGain);
            _S.GetUPnPService().GetStateVariableObject("RedVideoBlackLevel").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_RedVideoBlackLevel);
            _S.GetUPnPService().GetStateVariableObject("BlueVideoGain").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_BlueVideoGain);
            _S.GetUPnPService().GetStateVariableObject("Sharpness").OnModified += new UPnPStateVariable.ModifiedHandler(OnModifiedSink_Sharpness);
            _S.Sink_GetHorizontalKeystone = new Delegate_GetHorizontalKeystone(GetHorizontalKeystone);
            _S.Sink_GetVolume = new Delegate_GetVolume(GetVolume);
            _S.Sink_SelectPreset = new Delegate_SelectPreset(SelectPreset);
            _S.Sink_SetVolume = new Delegate_SetVolume(SetVolume);
            _S.Sink_ListPresets = new Delegate_ListPresets(ListPresets);
            _S.Sink_SetVolumeDB = new Delegate_SetVolumeDB(SetVolumeDB);
            _S.Sink_SetRedVideoBlackLevel = new Delegate_SetRedVideoBlackLevel(SetRedVideoBlackLevel);
            _S.Sink_SetContrast = new Delegate_SetContrast(SetContrast);
            _S.Sink_SetLoudness = new Delegate_SetLoudness(SetLoudness);
            _S.Sink_SetBrightness = new Delegate_SetBrightness(SetBrightness);
            _S.Sink_GetLoudness = new Delegate_GetLoudness(GetLoudness);
            _S.Sink_GetColorTemperature = new Delegate_GetColorTemperature(GetColorTemperature);
            _S.Sink_GetSharpness = new Delegate_GetSharpness(GetSharpness);
            _S.Sink_GetContrast = new Delegate_GetContrast(GetContrast);
            _S.Sink_GetGreenVideoGain = new Delegate_GetGreenVideoGain(GetGreenVideoGain);
            _S.Sink_SetRedVideoGain = new Delegate_SetRedVideoGain(SetRedVideoGain);
            _S.Sink_SetGreenVideoBlackLevel = new Delegate_SetGreenVideoBlackLevel(SetGreenVideoBlackLevel);
            _S.Sink_GetVolumeDBRange = new Delegate_GetVolumeDBRange(GetVolumeDBRange);
            _S.Sink_GetRedVideoBlackLevel = new Delegate_GetRedVideoBlackLevel(GetRedVideoBlackLevel);
            _S.Sink_GetBlueVideoBlackLevel = new Delegate_GetBlueVideoBlackLevel(GetBlueVideoBlackLevel);
            _S.Sink_GetBlueVideoGain = new Delegate_GetBlueVideoGain(GetBlueVideoGain);
            _S.Sink_SetBlueVideoBlackLevel = new Delegate_SetBlueVideoBlackLevel(SetBlueVideoBlackLevel);
            _S.Sink_GetMute = new Delegate_GetMute(GetMute);
            _S.Sink_SetBlueVideoGain = new Delegate_SetBlueVideoGain(SetBlueVideoGain);
            _S.Sink_GetVerticalKeystone = new Delegate_GetVerticalKeystone(GetVerticalKeystone);
            _S.Sink_SetVerticalKeystone = new Delegate_SetVerticalKeystone(SetVerticalKeystone);
            _S.Sink_GetBrightness = new Delegate_GetBrightness(GetBrightness);
            _S.Sink_GetVolumeDB = new Delegate_GetVolumeDB(GetVolumeDB);
            _S.Sink_GetGreenVideoBlackLevel = new Delegate_GetGreenVideoBlackLevel(GetGreenVideoBlackLevel);
            _S.Sink_GetRedVideoGain = new Delegate_GetRedVideoGain(GetRedVideoGain);
            _S.Sink_SetMute = new Delegate_SetMute(SetMute);
            _S.Sink_SetGreenVideoGain = new Delegate_SetGreenVideoGain(SetGreenVideoGain);
            _S.Sink_SetSharpness = new Delegate_SetSharpness(SetSharpness);
            _S.Sink_SetHorizontalKeystone = new Delegate_SetHorizontalKeystone(SetHorizontalKeystone);
            _S.Sink_SetColorTemperature = new Delegate_SetColorTemperature(SetColorTemperature);
        }
        public DvRenderingControl(string ID):this()
        {
            _S.GetUPnPService().ServiceID = ID;
        }
        public UPnPService GetUPnPService()
        {
            return(_S.GetUPnPService());
        }
        private void OnModifiedSink_VerticalKeystone(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_VerticalKeystone != null) OnStateVariableModified_VerticalKeystone(this);
        }
        private void OnModifiedSink_LastChange(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_LastChange != null) OnStateVariableModified_LastChange(this);
        }
        private void OnModifiedSink_A_ARG_TYPE_PresetName(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_A_ARG_TYPE_PresetName != null) OnStateVariableModified_A_ARG_TYPE_PresetName(this);
        }
        private void OnModifiedSink_Loudness(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_Loudness != null) OnStateVariableModified_Loudness(this);
        }
        private void OnModifiedSink_HorizontalKeystone(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_HorizontalKeystone != null) OnStateVariableModified_HorizontalKeystone(this);
        }
        private void OnModifiedSink_A_ARG_TYPE_InstanceID(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_A_ARG_TYPE_InstanceID != null) OnStateVariableModified_A_ARG_TYPE_InstanceID(this);
        }
        private void OnModifiedSink_BlueVideoBlackLevel(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_BlueVideoBlackLevel != null) OnStateVariableModified_BlueVideoBlackLevel(this);
        }
        private void OnModifiedSink_RedVideoGain(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_RedVideoGain != null) OnStateVariableModified_RedVideoGain(this);
        }
        private void OnModifiedSink_GreenVideoBlackLevel(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_GreenVideoBlackLevel != null) OnStateVariableModified_GreenVideoBlackLevel(this);
        }
        private void OnModifiedSink_Volume(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_Volume != null) OnStateVariableModified_Volume(this);
        }
        private void OnModifiedSink_Mute(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_Mute != null) OnStateVariableModified_Mute(this);
        }
        private void OnModifiedSink_Brightness(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_Brightness != null) OnStateVariableModified_Brightness(this);
        }
        private void OnModifiedSink_PresetNameList(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_PresetNameList != null) OnStateVariableModified_PresetNameList(this);
        }
        private void OnModifiedSink_A_ARG_TYPE_Channel(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_A_ARG_TYPE_Channel != null) OnStateVariableModified_A_ARG_TYPE_Channel(this);
        }
        private void OnModifiedSink_ColorTemperature(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_ColorTemperature != null) OnStateVariableModified_ColorTemperature(this);
        }
        private void OnModifiedSink_VolumeDB(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_VolumeDB != null) OnStateVariableModified_VolumeDB(this);
        }
        private void OnModifiedSink_Contrast(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_Contrast != null) OnStateVariableModified_Contrast(this);
        }
        private void OnModifiedSink_GreenVideoGain(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_GreenVideoGain != null) OnStateVariableModified_GreenVideoGain(this);
        }
        private void OnModifiedSink_RedVideoBlackLevel(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_RedVideoBlackLevel != null) OnStateVariableModified_RedVideoBlackLevel(this);
        }
        private void OnModifiedSink_BlueVideoGain(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_BlueVideoGain != null) OnStateVariableModified_BlueVideoGain(this);
        }
        private void OnModifiedSink_Sharpness(UPnPStateVariable sender, object NewValue)
        {
            if(OnStateVariableModified_Sharpness != null) OnStateVariableModified_Sharpness(this);
        }
        //}}}}} End of Code Block

        #endregion

        /// <summary>
        /// Action: GetHorizontalKeystone
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentHorizontalKeystone">Associated State Variable: HorizontalKeystone</param>
        public void GetHorizontalKeystone(System.UInt32 InstanceID, out System.Int16 CurrentHorizontalKeystone)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetVolume
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="Channel">Associated State Variable: A_ARG_TYPE_Channel</param>
        /// <param name="CurrentVolume">Associated State Variable: Volume</param>
        public void GetVolume(System.UInt32 InstanceID, Enum_A_ARG_TYPE_Channel Channel, out System.UInt16 CurrentVolume)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SelectPreset
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="PresetName">Associated State Variable: A_ARG_TYPE_PresetName</param>
        public void SelectPreset(System.UInt32 InstanceID, Enum_A_ARG_TYPE_PresetName PresetName)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetVolume
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="Channel">Associated State Variable: A_ARG_TYPE_Channel</param>
        /// <param name="DesiredVolume">Associated State Variable: Volume</param>
        public void SetVolume(System.UInt32 InstanceID, Enum_A_ARG_TYPE_Channel Channel, System.UInt16 DesiredVolume)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: ListPresets
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentPresetNameList">Associated State Variable: PresetNameList</param>
        public void ListPresets(System.UInt32 InstanceID, out System.String CurrentPresetNameList)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetVolumeDB
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="Channel">Associated State Variable: A_ARG_TYPE_Channel</param>
        /// <param name="DesiredVolume">Associated State Variable: VolumeDB</param>
        public void SetVolumeDB(System.UInt32 InstanceID, Enum_A_ARG_TYPE_Channel Channel, System.Int16 DesiredVolume)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetRedVideoBlackLevel
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredRedVideoBlackLevel">Associated State Variable: RedVideoBlackLevel</param>
        public void SetRedVideoBlackLevel(System.UInt32 InstanceID, System.UInt16 DesiredRedVideoBlackLevel)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetContrast
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredContrast">Associated State Variable: Contrast</param>
        public void SetContrast(System.UInt32 InstanceID, System.UInt16 DesiredContrast)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetLoudness
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="Channel">Associated State Variable: A_ARG_TYPE_Channel</param>
        /// <param name="DesiredLoudness">Associated State Variable: Loudness</param>
        public void SetLoudness(System.UInt32 InstanceID, Enum_A_ARG_TYPE_Channel Channel, System.Boolean DesiredLoudness)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetBrightness
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredBrightness">Associated State Variable: Brightness</param>
        public void SetBrightness(System.UInt32 InstanceID, System.UInt16 DesiredBrightness)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetLoudness
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="Channel">Associated State Variable: A_ARG_TYPE_Channel</param>
        /// <param name="CurrentLoudness">Associated State Variable: Loudness</param>
        public void GetLoudness(System.UInt32 InstanceID, Enum_A_ARG_TYPE_Channel Channel, out System.Boolean CurrentLoudness)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetColorTemperature
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentColorTemperature">Associated State Variable: ColorTemperature</param>
        public void GetColorTemperature(System.UInt32 InstanceID, out System.UInt16 CurrentColorTemperature)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetSharpness
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentSharpness">Associated State Variable: Sharpness</param>
        public void GetSharpness(System.UInt32 InstanceID, out System.UInt16 CurrentSharpness)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetContrast
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentContrast">Associated State Variable: Contrast</param>
        public void GetContrast(System.UInt32 InstanceID, out System.UInt16 CurrentContrast)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetGreenVideoGain
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentGreenVideoGain">Associated State Variable: GreenVideoGain</param>
        public void GetGreenVideoGain(System.UInt32 InstanceID, out System.UInt16 CurrentGreenVideoGain)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetRedVideoGain
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredRedVideoGain">Associated State Variable: RedVideoGain</param>
        public void SetRedVideoGain(System.UInt32 InstanceID, System.UInt16 DesiredRedVideoGain)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetGreenVideoBlackLevel
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredGreenVideoBlackLevel">Associated State Variable: GreenVideoBlackLevel</param>
        public void SetGreenVideoBlackLevel(System.UInt32 InstanceID, System.UInt16 DesiredGreenVideoBlackLevel)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetVolumeDBRange
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="Channel">Associated State Variable: A_ARG_TYPE_Channel</param>
        /// <param name="MinValue">Associated State Variable: VolumeDB</param>
        /// <param name="MaxValue">Associated State Variable: VolumeDB</param>
        public void GetVolumeDBRange(System.UInt32 InstanceID, Enum_A_ARG_TYPE_Channel Channel, out System.Int16 MinValue, out System.Int16 MaxValue)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetRedVideoBlackLevel
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentRedVideoBlackLevel">Associated State Variable: RedVideoBlackLevel</param>
        public void GetRedVideoBlackLevel(System.UInt32 InstanceID, out System.UInt16 CurrentRedVideoBlackLevel)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetBlueVideoBlackLevel
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentBlueVideoBlackLevel">Associated State Variable: BlueVideoBlackLevel</param>
        public void GetBlueVideoBlackLevel(System.UInt32 InstanceID, out System.UInt16 CurrentBlueVideoBlackLevel)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetBlueVideoGain
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentBlueVideoGain">Associated State Variable: BlueVideoGain</param>
        public void GetBlueVideoGain(System.UInt32 InstanceID, out System.UInt16 CurrentBlueVideoGain)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetBlueVideoBlackLevel
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredBlueVideoBlackLevel">Associated State Variable: BlueVideoBlackLevel</param>
        public void SetBlueVideoBlackLevel(System.UInt32 InstanceID, System.UInt16 DesiredBlueVideoBlackLevel)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetMute
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="Channel">Associated State Variable: A_ARG_TYPE_Channel</param>
        /// <param name="CurrentMute">Associated State Variable: Mute</param>
        public void GetMute(System.UInt32 InstanceID, Enum_A_ARG_TYPE_Channel Channel, out System.Boolean CurrentMute)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetBlueVideoGain
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredBlueVideoGain">Associated State Variable: BlueVideoGain</param>
        public void SetBlueVideoGain(System.UInt32 InstanceID, System.UInt16 DesiredBlueVideoGain)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetVerticalKeystone
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentVerticalKeystone">Associated State Variable: VerticalKeystone</param>
        public void GetVerticalKeystone(System.UInt32 InstanceID, out System.Int16 CurrentVerticalKeystone)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetVerticalKeystone
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredVerticalKeystone">Associated State Variable: VerticalKeystone</param>
        public void SetVerticalKeystone(System.UInt32 InstanceID, System.Int16 DesiredVerticalKeystone)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetBrightness
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentBrightness">Associated State Variable: Brightness</param>
        public void GetBrightness(System.UInt32 InstanceID, out System.UInt16 CurrentBrightness)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetVolumeDB
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="Channel">Associated State Variable: A_ARG_TYPE_Channel</param>
        /// <param name="CurrentVolume">Associated State Variable: VolumeDB</param>
        public void GetVolumeDB(System.UInt32 InstanceID, Enum_A_ARG_TYPE_Channel Channel, out System.Int16 CurrentVolume)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetGreenVideoBlackLevel
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentGreenVideoBlackLevel">Associated State Variable: GreenVideoBlackLevel</param>
        public void GetGreenVideoBlackLevel(System.UInt32 InstanceID, out System.UInt16 CurrentGreenVideoBlackLevel)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: GetRedVideoGain
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="CurrentRedVideoGain">Associated State Variable: RedVideoGain</param>
        public void GetRedVideoGain(System.UInt32 InstanceID, out System.UInt16 CurrentRedVideoGain)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetMute
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="Channel">Associated State Variable: A_ARG_TYPE_Channel</param>
        /// <param name="DesiredMute">Associated State Variable: Mute</param>
        public void SetMute(System.UInt32 InstanceID, Enum_A_ARG_TYPE_Channel Channel, System.Boolean DesiredMute)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetGreenVideoGain
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredGreenVideoGain">Associated State Variable: GreenVideoGain</param>
        public void SetGreenVideoGain(System.UInt32 InstanceID, System.UInt16 DesiredGreenVideoGain)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetSharpness
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredSharpness">Associated State Variable: Sharpness</param>
        public void SetSharpness(System.UInt32 InstanceID, System.UInt16 DesiredSharpness)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetHorizontalKeystone
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredHorizontalKeystone">Associated State Variable: HorizontalKeystone</param>
        public void SetHorizontalKeystone(System.UInt32 InstanceID, System.Int16 DesiredHorizontalKeystone)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
        /// <summary>
        /// Action: SetColorTemperature
        /// </summary>
        /// <param name="InstanceID">Associated State Variable: A_ARG_TYPE_InstanceID</param>
        /// <param name="DesiredColorTemperature">Associated State Variable: ColorTemperature</param>
        public void SetColorTemperature(System.UInt32 InstanceID, System.UInt16 DesiredColorTemperature)
        {
            //ToDo: Add Your implementation here, and remove exception
            throw(new UPnPCustomException(800,"This method has not been completely implemented..."));
        }
    }
}